Efficient and Type-Safe Generic Data Storage

AbstractIn this paper we present an elegant method for sequentializing arbitrary data using the generic language extension of the functional programming language Clean. We show how the proposed operations can be used to store values of any concrete data type in several kinds of IO containers (such as files or arrays of characters), and how to manipulate stored data efficiently. Moreover, by extending stored data with encoded type information, data manipulation will be type-safe. Defining these operations generically has the advantage that specific instances for user defined data types can be generated fully automatically. Compared to traditional sequentialization methods (or to common data manipulation, using relational data bases) our operations are an order of magnitude faster

Putting Types To Good Use

Contains fulltext : 30218.pdf (publisher's version ) (Open Access)Writing correct software is still difficult due to its increasing complexity, which requires many abstraction layers. We believe that functional programming languages might alleviate some of those difficulties at the source of software construction. Pure and lazy languages, like Clean and Haskell, provide very good support for abstraction, composition, and equational reasoning. They also feature advanced type systems, which can be used to warn programmers about a certain class of mistakes early. This thesis investigates the usefulness of hybrid static/dynamic typing and polytypic programming by applying these techniques to some common software or programming problems. We show those two techniques 'in action' to assess applicability, performance, and expressiveness of the programming techniques themselves, as well as their implementations in both Clean and (Generic) Haskell. The hybrid static/dynamic typing is exciting in the way it extends the type safety of a strongly typed functional language into the run-time world. The polytypic programming approach to writing software is attractive in its promise to reduce the amount of code that needs to be written, to enable better maintenance by adding code instead of rewriting, and to elegantly describe abstract algorithms that work for any data structure. We conclude, from the research presented, that Clean's hybrid static/dynamic typing provides us with additional protection against run-time errors by tagging values with their static types. Furthermore, it provides us with a way to store and retrieve any functional expression, even between different programs. Polytypic programming also keeps us from making mistakes in (tediously) writing similar code for many data types. Because the automatic derivation/instantiating of polytypic functions is both type directed and type safe (it cannot introduce type errors), there is less room for programming errors.Radboud University Nijmegen, 17 oktober 2007Promotor : Plasmeijer, R.X, 187 p

Bracket Abstraction Preserves Typability - A formal proof of Diller-algorithm-C in PVS

Item does not contain fulltex

A Functional Shell that Operates on Typed and Compiled Applications

Abstract. Esther is the interactive shell of Famke, a prototype implementation of a strongly typed operating system written in the functional programming language Clean. As usual, the shell can be used for manipulating files, applications, data and processes at the command line. Special about Esther is that the shell language provides the full basic functionality of a strongly typed lazy functional language. The shell type checks each command line and only executes well-typed expressions. Files are typed as well, and applications are simply files with a function type. The implementation of the shell has some unusual aspects. The type checking/inferencing performed by the shell is actually performed by the hybrid static/dynamic type system of Clean. The shell behaves like an interpreter, but it actually executes a command line by combining existing code of functions on disk. Cleans dynamic linker is used to store (and retrieve) any expression (both data and code) with its type on disk. This linker is also used to communicate values of any type, e.g., data, closures, and functions (i.e.compiled code), between running applications in a type safe way. The shell combines the advantages of interpreters (direct response) and compilers (statically typed, fast code). Applications (compiled functions) can be used, in a type safe way, in the shell, and functions defined in the shell can be used by any compiled application.

Polytypic Syntax Tree Operations

Item does not contain fulltextIFL 200

GEC: A Toolkit for Generic Rapid Prototyping of Type Safe Interactive Applications

Programming GUIs with conventional GUI APIs is notoriously tedious. In these notes we present the GEC toolkit in which the programmer can create user interfaces without any knowledge of lowlevel I/O handling. Instead, he works with Graphical Editor Components (GEC). A GEC is an interactive component that is automatically derived from an arbitrary monomorphic data type, including higher order types

A Functional Shell That Operates on Typed and Compiled Applications

Esther is the interactive shell of Famke, a prototype implementation of a strongly typed operating system written in the functional programming language Clean. As usual, the shell can be used for manipulating files, applications, data and processes at the command line